Recording GUI data

ABSTRACT

A system for recording the interaction of a computer program via graphical user interface (GUI) is disclosed in which one or more operating system event queues are monitored and GUI interaction data logged.

BACKGROUND OF THE INVENTION

The present invention relates to a system for recording graphical userinterface (GUI) data.

Computer systems commonly run software such as application or systemsoftware which enable interaction with a user via one or more graphicaluser interfaces (GUIs). When a problem occurs with such software, theresolution of the problem is generally more efficient if the resolvercan observe the user's interactions with the GUI relevant to occurrenceof the problem. The GUI windows and user interactions for a program thatform the context of an issue may be useful or essential for resolvingthat issue.

One solution for providing such contextual GUI information includes theuser re-creating the problem and capturing the GUI state by takingscreen shots, which are then used for the diagnosis process. Howeverthis is a time consuming process, which may not result in the relevantdata being captured. Another solution includes recording a video of theGUI context for the problem. However, video recordings requireadditional equipment and commonly result in large video files that maybe difficult to communicate over a network. Furthermore, both screenshots and videos of GUI may result in the inadvertent provision ofconfidential or sensitive data.

SUMMARY

One aspect of the invention provides apparatus for recording graphicaluser interface (GUI) data for a computer program, the apparatusincluding one or more processors arranged to: monitor an event queueassociated with a GUI for a program, identify a first message on theevent queue defining a window of the GUI for the program, log datarepresenting the window in a log associated with the program, identifyfurther messages on the event queue defining one or more updates to thewindow, identify the net change to the window defined in the furthermessages, and log data representing the identified net change to thewindow in the log.

Embodiments of the invention provide accurate reconstruction at apredetermined resolution of GUI interactions. This aids swiftunderstanding for an observer of the relevant GUI interactions toenable, for example, the swifter diagnosis of a user's problem. The GUIsimulation is easily understood as it mimics the real GUI interaction.The GUI interaction data is collected automatically without userinteraction required for its collection. The GUI log data may becollected in real-time so there is no need for a user to reconstruct agiven issue. There is no need for the program being monitored to beinstrumented, have code added, or be rewritten. The GUI log file isrelatively compact for efficient communication or storage.

The data representing the window may include a serialization of thewindow. The data representing the net change to the window may include aserialization of the changes to the window. The data representing thewindow or the net change to the window may be derived from therespective identified message(s) on the event queue. One or moremessages on the event queue may define user input to the window of theGUI for the program. The logging of the data associated with the or eachfurther message identified on the event queue may be triggered inaccordance with a predetermined logging period. The logging period maybe determined by time or message data content or message data quantity.One or more predetermined sets of data may be omitted from or redactedin the log. The logged data may include XML. The event queue may includean operating system (OS) event queue or application program event queue.

The apparatus may be further operable to identify a log file for aselected application program, and display the recorded GUI activity fromthe log file entries as a simulation of the application program GUI.

Another aspect of the invention provides a method for recordinggraphical user interface (GUI) data for a computer program, the methodincluding monitoring an event queue associated with a GUI for a program,identifying a first message on the event queue defining a window of theGUI for the program, logging data representing the window in a logassociated with the program, identifying further messages on the eventqueue defining one or more updates to the window, identifying the netchange to the window defined in the further messages, and logging datarepresenting the identified net change to the window in the log.

A further aspect of the invention provides a computer program productfor recording GUI data for a computer program, the computer programproduct including a computer-readable storage medium havingcomputer-readable program code embodied therewith, the computer-readableprogram code configured to: monitor an event queue associated with a GUIfor a program, identify a first message on the event queue defining awindow of the GUI for the program, log data representing the window in alog associated with the program, identify further messages on the eventqueue defining one or more updates to the window, identify the netchange to the window defined in the further messages, and log datarepresenting the identified net change to the window in the log.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the invention will now be described, by way of exampleonly, with reference to the following drawings in which:

FIG. 1 is a schematic representation of a computer system including acomputer, display, keyboard and mouse;

FIG. 2 is a schematic representation of software running on the computerof FIG. 1 including a GUI logging application program and a GUIsimulation application program;

FIG. 3 is a schematic representation of GUI log data logged by the GUIlogging application program of FIG. 2;

FIG. 4 is a flow chart illustrating the processing performed by the GUIlogging application program of FIG. 2 when creating the log of FIG. 3;

FIG. 5 is a flow chart illustrating further processing performed by theGUI logging application program of FIG. 2 when creating the log of FIG.3; and

FIG. 6 is a flow chart illustrating the processing performed by the GUIsimulation application program of FIG. 2 when simulating the activity ofthe application program GUI from the data recorded in the log file ofFIG. 3.

DETAILED DESCRIPTION

With reference to FIG. 1, a computer system 101 includes a computer 103with a connected display 105, keyboard 107 and mouse 109. The computer103 is running an operating system (OS) 111 arranged to provide awindow-based graphical user interface (GUI) 113 via the display 105. Thekeyboard 107 and mouse 109 enable a user to interact with the OS 111 andone or more application programs (not shown) by entering or modifyingdata and controlling elements of the GUI 113. Such interaction mayresult in changes to the GUI 113 in terms of the displayed window ordata.

With reference to FIG. 2, the computer 103 is running a user applicationprogram 201 and a GUI logging application program 203. The userapplication program 201 is arranged to enable interaction with a uservia the GUI 113 to enable the opening and control of GUI windows 113 andthe input and modification of data via the user application program 201in response to user inputs via the keyboard 107 and mouse 109. In oneembodiment, the OS 111 has a message-based event-driven architecture andincludes a GUI event queue 205. The GUI event queue 205 is provided bythe OS 111 and arranged for managing communications between the user andOS 111 via the GUI 113 on one side and the user application program 201on the other side. Communications are message based with relevantmessages being put on the GUI event queue 205 by a sender and read fromthe GUI event queue 205 by the intended receiver. Examples of messagestypes and their relevant data placed on the GUI event queue 205 are asfollows:

Open window: size, color, layout, buttons, fields, and data;

Modify window: resize, add/remove/modify display data;

Close window;

Keyboard input; and

Mouse input.

The GUI logging application program 203 is arranged to listen to ormonitor the GUI event queue 205 for messages related to a selectedapplication program such as the user application program 201. Inresponse to messages put on the GUI event queue 205 to or from the userapplication program 201, the GUI logging application program 203 isarranged to record data representing those messages in a GUI log datafile 207. Where a given message represents a new window, the GUI loggingapplication program 203 is arranged to store data representing that newwindow in a corresponding entry in the GUI log data file 207. In oneembodiment, the data stored in the GUI log data file 207 includes aserialization of the new window message. Where a group of one orsubsequent messages identified on the GUI event queue 205 representmodifications, updates or user input to an existing window, the GUIlogging application program 203 is arranged to determine the net changein the window represented by the subsequent messages. The GUI loggingapplication program 203 is then arranged to save data representing thenet change to the window for a predetermined logging period. In oneembodiment, the logging period is time based and includes a five secondperiod. In other words, the messages modifying an existing GUI windowthat are identified on the GUI event queue 205 within a given loggingperiod are compressed, as noted above, by identifying the net change inthe relevant window that those messages represent. The data representingthe net change or delta is then stored in a corresponding entry in theGUI log data file 207 in association with an indication of the relevantlogging period.

With reference to FIG. 3, in one embodiment the GUI logging applicationprogram 203 is arranged to create a GUI log data file 207 for eachapplication program being monitored. Furthermore, discrete datasets arerecorded for each window opened by the monitored application program. Inthe example of FIG. 3, the GUI log data file 207 includes three datasets301, 302, 303 indicating that the user application program 201 hasopened three windows 113. Each dataset 301, 302, 303 includes a sequenceof entries as described above including an initial entry, representingthe newly opened window, follow by a series of further entriesrepresenting the net change for the relevant logging period resultingfrom outputs from the monitored application program 201 or user inputsvia the keyboard 107 or mouse 109.

The processing performed by the GUI logging application program 203 willnow be described further with reference to an example in which the userapplication 201 opens a new window including a button and a text inputfield, the user then inputs the text “Hello World” in the text fieldusing the keyboard 107 and then clicks the button using the mouse 109.The initial window has the window handle “747” and results in thefollowing entry in the GUI log data file 207:

-   -   Time=10:00:00    -   Window-com.ibm.gui.window1-opened-windowHandle_747    -   750_ButtonCreated    -   750_x=100    -   750_y=50    -   750_text=OK    -   751_TextFieldCreated    -   751_x=10    -   751_y=10

The subsequent text input by the user via the keyboard in the nextlogging period results in the following addition to the entry in the GUIlog data file 207:

-   -   Time=10:00:05    -   752_TextnputEventCreatedFor_751    -   752_data=Hello World    -   750_ButtonClickedEventCreatedFor_750

In the next logging period the user enters the text “A”, then waits 2seconds and enters “B” and then presses OK and then gets an errormessage back that says, “The data must be three characters”. The userthen enters “CDEF” and presses OK and the button's label changes to“Finish”. Without data compression this would result in the followingentries in the GUI log data file 207:

-   -   Time=10:00:10    -   752_KeyPressEventCreatedFor_751    -   752_data=A    -   Time=10:00:12    -   752_KeyPressEventCreatedFor_751    -   752_data=B    -   750_ButtonClickedEventCreatedFor_750    -   747_Message_display=“The data must be three characters”    -   Time=10:00:13    -   752_KeyPressEventCreatedFor_751    -   752_data=CDEF    -   750_ButtonClickedEventCreatedFor_750    -   747_Message_display=“ ”    -   750_Button_text=Finish

Once the above message data is compressed for the logging period onlythe net change is captured, which is that the text “ABCDEF” was enteredand the button's text label changed:

-   -   Time=10:00:10 to 10:00:15    -   752_KeyPressEventCreatedFor_751    -   752_data=ABCDEF    -   750_Button_text=Finish

Returning to FIG. 2, in one embodiment, the computer 103 is also runninga GUI simulation application program 209 arranged to display simulationsof GUI interactions of a user and an application program such as theuser application program 201. The GUI simulation application program 209uses the data recorded in the relevant GUI log data file 207 to providesuch simulations. In one embodiment, the GUI simulation applicationprogram 209 is arranged to display a simulation of the relevant GUIinteractions within a GUI interaction replay window. The GUI simulationapplication program 209 is arranged to input the GUI log data file 207and to create the lightweight simulation of the corresponding GUIactivity captured in the GUI log data file 207. In one embodiment, theGUI simulation application program 209 is further arranged to optionallyaugment the simulation with additional information from the log filesuch as logging period data.

The processing performed by the GUI logging application program 203 willnow be described further with reference to the flow charts of FIGS. 4and 5. Processing is initiated at step 401 in response to the startup ofthe GUI logging application program 203 and processing then moves tostep 403. At step 403 the instance of the relevant application programto be monitored is identified and processing moves to step 405. At step405 monitoring of the GUI event queue 205 is initiated for eventsrelating to the identified instance of the application program 201 beingmonitored and processing moves to step 407. At step 407 each messagerelating to the monitored application program 201 that is placed on theGUI event queue is logged in the relevant GUI log data file 207 asdescribed above. See FIG. 5 for further details regarding step 407. Thisprocess continues until either the GUI logging application program 203is stopped or the instance of the application program 201 beingmonitored ends at which point processing moves to step 411 and ends.

The processing performed by the GUI logging application program 203 instep 407 of the flow chart of FIG. 4 will now be described further withreference to the flow chart of FIG. 5. Processing is initiated from step407 and moves to step 501 where the GUI event queue 205 is monitored fornew messages relating to the user application program 201. When a newmessage is identified on the GUI event queue 205 processing moves tostep 503. At step 503 if the new message relates to the creation of anew window 113 then processing moves to step 505. At step 505 the newwindow event message is captured and serialized, an associated loggingperiod is initiated and processing moves to step 507. At step 507 theserialized message is stored in the GUI log data file 207 and processingreturns to step 501 to await the next relevant message on the GUI eventqueue 205.

If at step 503 the new message is not related to a new window thenprocessing moves to step 509. If at step 509 the message relates to theupdating or modification of an existing window, for example as a resultof user input or output from the user application program 201 thenprocessing moves to step 511. At step 511 if the current logging periodfor the relevant window has yet to expire then processing moves to step513. At step 513 the new message is buffered to await the end of thecurrent logging period and processing then returns to step 501 to awaita further message on the GUI message queue 205.

If however at step 511 the current logging period for the relevantwindow has expired then processing moves to step 515. At step 515 thenet change represented by the current message and any prior messagesbuffered for the current logging period is determined and processingmoves to step 517. At step 517 the data representing the net change isserialized and stored in the relevant dataset 301, 302, 303 for thewindow 113 in the GUI log file 207 for the relevant logging period andprocessing returns to step 501 to await a further message on the GUImessage queue 205. If at step 509 the new message relates to neither anew window (503) nor a change to an existing window then processingmoves to step 519. If at step 519 the new message relates to the closingof a window of one of the monitored windows of the application program201 then processing moves to step 521. At step 521 the close event isserialized and saved to the relevant dataset 301, 302, 303 for thewindow and processing returns to step 501 to await a further message onthe GUI message queue 205. If at step 519 the new message relates toneither a new window (503) nor a change to an existing window (509) northe closure of an existing window then processing skips the message andreturns to step 501 to await a further message on the GUI message queue205.

The processing performed by the GUI simulation application program 209will now be described further with reference to the flow chart of FIG.6. Processing is initiated by a user at step 601 and moves to step 603.At step 603 the relevant GUI log data file 207 is identified andprocessing moves to step 605. At step 605 a new GUI window 113 is openedin which the simulation will be replayed and processing moves to step607. At step 607 each entry in the GUI log data file 207 is steppedthrough and the corresponding GUI events are displayed in logging periodorder in the replay window 113. The simulation can be repeated, pausedor reversed under user control or ended in which case processing movesto step 609 and ends.

In a further embodiment, the GUI logging application program is arrangedto log the accumulated GUI input in the GUI log file in response to thedetection of selected GUI input on the GUI event queue. For example, GUIdata logging may be triggered by significant keyboard interactions thatare driving the application, such as button clicks or window close andopen events. The GUI logging application program may be arranged to waitfor a predetermined period triggered by the detection of the selectedGUI input before performing the logging. The pause or delay period maybe user determined.

In another embodiment, the GUI logging application program is arrangedto omit predetermined types of data from the GUI log file. The types ofdata omitted may be determined by the user or enforced by the GUIlogging application program. For example, all data may be omitted orselected sensitive or private data types omitted. Such data may beredacted or removed altogether or replaced with obscured or randomizeddata.

In a further embodiment, the GUI logging application program is arrangedto augment the GUI log file with further timing data or with otherapplication or system data such as memory, task usage or processorresource data. Such additional data may be displayed as appropriate bythe GUI simulation program.

In another embodiment the logging period is determined by a quantity ofdata input or output for the GUI of the monitored application. Forexample, the number or cumulative size of messages on the monitoredevent queue of one or more types may determine the logging period for agiven window. The logging period may be determined by the amount of dataupdated to a given window.

In a further embodiment, instead of each window in a given monitored GUIhaving its own logging period as described above, a global loggingperiod is defined at the end of which the cumulative events for allwindows are logged.

Embodiments of the invention provide accurate reconstruction at apredetermined resolution of GUI interactions. This aids swiftunderstanding for an observer of the relevant GUI interactions toenable, for example, the swifter diagnosis of a user's problem. The GUIsimulation is easily understood as it mimics the real GUI interaction.The GUI interaction data is collected automatically without userinteraction required for its collection. The GUI log data may becollected in real-time so there is no need for a user to reconstruct agiven issue. There is no need for program being monitored to beinstrumented, have code added, or be rewritten. Embodiments of theinvention provide passive logging of GUI interactions during the normaloperation of the monitored program. The GUI log file data can be readmanually or replayed as a simulation. The data contained in the log filecan be tailored or controlled depending on a given application of theembodiment. The GUI log file is relatively compact for efficientcommunication or storage.

As will be understood by those skilled in the art, the serializationmethod used for creating data for the GUI log depends on the GUI toolkitused for a given system. For example if the GUI toolkit makes use of theJavaBeans™ Encoder then the GUI data may be serialized in XML(eXtensible Markup Language; Java and all Java-based trademarks andlogos are trademarks or registered trademarks of Oracle and/or itsaffiliates).

As will be understood by those skilled in the art, any suitable eventqueue may be used to monitor the GUI output or input for a program ofinterest. For example, a general event queue may be monitored, forexample, provided by an OS or a specific event queue of the OS orapplication may be monitored. Furthermore, more than one event queue maybe monitored and the relevant messages identified and logged.

As will be understood by those skilled in the art, any input or outputin addition to GUI input or output for a program may be monitored andlogged as appropriate. Other selected input or output determined asrelevant to the program being monitored may be logged such as input oroutput from the OS or other program.

As will be understood by those skilled in the art, not all input oroutput data of an application program being monitored need be logged.For example, only GUI activity output by the application may be loggedand any user GUI input such as keyboard or mouse input omitted.

As will be understood by those skilled in the art, while the system isdescribed above in relation to a single computer, the functions of thesystem may divided as appropriate into a client and server architecture.In addition, the GUI logging application program and the GUI simulationapplication program may be run on separate computers with the relevantGUI log files being communicated from one to the other by any suitablemeans such as over a network.

As will be understood by those skilled in the art, the GUI user inputmay be provided by any suitable input device including virtual or softdevices such as soft-keyboards.

As will be understood by those skilled in the art that the apparatusthat embodies a part or all of the present invention may be a generalpurpose device having software arranged to provide a part or all of anembodiment of the invention. The device could be a single device or agroup of devices and the software could be a single program or a set ofprograms. Furthermore, any or all of the software used to implement theinvention can be communicated via any suitable transmission or storagemeans so that the software can be loaded onto one or more devices.

While the present invention has been illustrated by the description ofthe embodiments thereof, and while the embodiments have been describedin considerable detail, it is not the intention of the applicant torestrict or in any way limit the scope of the appended claims to suchdetail. Additional advantages and modifications will readily appear tothose skilled in the art. Therefore, the invention in its broaderaspects is not limited to the specific details of the representativeapparatus and method, and illustrative examples shown and described.Accordingly, departures may be made from such details without departurefrom the scope of applicant's general inventive concept.

As will be appreciated by one skilled in the art, aspects of the presentinvention may be embodied as a system, method or computer programproduct. Accordingly, aspects of the present invention may take the formof an entirely hardware embodiment, an entirely software embodiment(including firmware, resident software, micro-code, etc.) or anembodiment combining software and hardware aspects that may allgenerally be referred to herein as a “circuit,” “module” or “system.”Furthermore, aspects of the present invention may take the form of acomputer program product embodied in one or more computer readablemedium(s) having computer readable program code embodied thereon.

Any combination of one or more computer readable medium(s) may beutilized. The computer readable medium may be a computer readable signalmedium or a computer readable storage medium. A computer readablestorage medium may be, for example, but not limited to, an electronic,magnetic, optical, electromagnetic, infrared, or semiconductor system,apparatus, or device, or any suitable combination of the foregoing. Morespecific examples (a non-exhaustive list) of the computer readablestorage medium would include the following: an electrical connectionhaving one or more wires, a portable computer diskette, a hard disk, arandom access memory (RAM), a read-only memory (ROM), an erasableprogrammable read-only memory (EPROM or Flash memory), an optical fiber,a portable compact disc read-only memory (CD-ROM), compact discread/write (CD-R/W) or DVD disc, an optical storage device, a magneticstorage device, or any suitable combination of the foregoing. In thecontext of this document, a computer readable storage medium may be anytangible medium that can contain, or store a program for use by or inconnection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signalwith computer readable program code embodied therein, for example, inbaseband or as part of a carrier wave. Such a propagated signal may takeany of a variety of forms, including, but not limited to,electro-magnetic, optical, or any suitable combination thereof. Acomputer readable signal medium may be any computer readable medium thatis not a computer readable storage medium and that can communicate,propagate, or transport a program for use by or in connection with aninstruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmittedusing any appropriate medium, including but not limited to wireless,wireline, optical fiber cable, RF, etc., or any suitable combination ofthe foregoing.

Computer program code for carrying out operations for aspects of thepresent invention may be written in any combination of one or moreprogramming languages, including an object oriented programming languagesuch as Java, Smalltalk, C++ or the like and conventional proceduralprogramming languages, such as the “C” programming language or similarprogramming languages (Java and all Java-based trademarks and logos aretrademarks or registered trademarks of Oracle and/or its affiliates;other marks may be trademarks or registered trademarks of theirrespective owners). The program code may execute entirely on the user'scomputer, partly on the user's computer, as a stand-alone softwarepackage, partly on the user's computer and partly on a remote computeror entirely on the remote computer or server. In the latter scenario,the remote computer may be connected to the user's computer through anytype of network, including a local area network (LAN) or a wide areanetwork (WAN), or the connection may be made to an external computer(for example, through the Internet using an Internet Service Provider).

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems) and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer program instructions. These computer program instructions maybe provided to a processor of a general purpose computer, specialpurpose computer, or other programmable data processing apparatus toproduce a machine, such that the instructions, which execute via theprocessor of the computer or other programmable data processingapparatus, create means for implementing the functions/acts specified inthe flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computerreadable medium that can direct a computer, other programmable dataprocessing apparatus, or other devices to function in a particularmanner, such that the instructions stored in the computer readablemedium produce an article of manufacture including instructions whichimplement the function/act specified in the flowchart and/or blockdiagram block or blocks.

The computer program instructions may also be loaded onto a computer,other programmable data processing apparatus, or other devices to causea series of operational steps to be performed on the computer, otherprogrammable apparatus or other devices to produce a computerimplemented process such that the instructions which execute on thecomputer or other programmable apparatus provide processes forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks.

It will be equally clear to one of skill in the art that all or part ofa logic arrangement according to the preferred embodiments of thepresent invention may suitably be embodied in a logic apparatuscomprising logic elements to perform the steps of the method, and thatsuch logic elements may comprise components such as logic gates in, forexample a programmable logic array or application-specific integratedcircuit. Such a logic arrangement may further be embodied in enablingelements for temporarily or permanently establishing logic structures insuch an array or circuit using, for example, a virtual hardwaredescriptor language, which may be stored and transmitted using fixed ortransmittable carrier media.

In one alternative, a preferred embodiment of the present invention maybe realized in the form of a computer implemented method of deploying aservice comprising steps of deploying computer program code operable to,when deployed into a computer infrastructure and executed thereon, causesaid computer system to perform all the steps of the method.

In a further alternative, a preferred embodiment of the presentinvention may be realized in the form of a data carrier havingfunctional data thereon, said functional data comprising functionalcomputer data structures to, when loaded into a computer system andoperated upon thereby, enable said computer system to perform all thesteps of the method.

Note further that any methods described in the present disclosure may beimplemented through the use of a VHDL (VHSIC Hardware DescriptionLanguage) program and a VHDL chip. VHDL is an exemplary design-entrylanguage for Field Programmable Gate Arrays (FPGAs), ApplicationSpecific Integrated Circuits (ASICs), and other similar electronicdevices. Thus, any software-implemented method described herein may beemulated by a hardware-based VHDL program, which is then applied to aVHDL chip, such as an FPGA.

A method is generally conceived to be a self-consistent sequence ofsteps leading to a desired result. These steps require physicalmanipulations of physical quantities. Usually, though not necessarily,these quantities take the form of electrical or magnetic signals capableof being stored, transferred, combined, compared, and otherwisemanipulated. It is convenient at times, principally for reasons ofcommon usage, to refer to these signals as bits, values, parameters,items, elements, objects, symbols, characters, terms, numbers, or thelike. It should be noted, however, that all of these terms and similarterms are to be associated with the appropriate physical quantities andare merely convenient labels applied to these quantities.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof code, which comprises one or more executable instructions forimplementing the specified logical function(s). It should also be notedthat, in some alternative implementations, the functions noted in theblock may occur out of the order noted in the figures. For example, twoblocks shown in succession may, in fact, be executed substantiallyconcurrently, or the blocks may sometimes be executed in the reverseorder, depending upon the functionality involved. It will also be notedthat each block of the block diagrams and/or flowchart illustration, andcombinations of blocks in the block diagrams and/or flowchartillustration, can be implemented by special purpose hardware-basedsystems that perform the specified functions or acts, or combinations ofspecial purpose hardware and computer instructions.

It will be clear to one skilled in the art that many improvements andmodifications can be made to the foregoing exemplary embodiment withoutdeparting from the scope of the present invention.

The invention claimed is:
 1. An apparatus for recording graphical userinterface (GUI) data for a computer program, the apparatus comprisingone or more processors arranged to: monitor an operating system eventqueue associated with a GUI for a program; identify a first message onthe operating system event queue defining a window of the GUI for theprogram; log data representing the window in a log associated with theprogram, wherein the log is used to display a recorded GUI activity as asimulation of the program, and wherein the logging of the data istriggered in accordance with a predetermined logging period associatedwith time, message data content, or message data quantity; identify oneor more further messages on the operating system event queue definingone or more updates to the window; identify a net change to the windowdefined in the further messages; and log data representing theidentified net change to the window in the log.
 2. The apparatusaccording to claim 1 wherein the data representing the window comprisesa serialization of the window.
 3. The apparatus according to claim 1wherein the data representing the net change to the window comprises aserialization of one or more changes to the window.
 4. The apparatusaccording to claim 1 wherein the data representing the window and thedata representing the net change to the window are derived from theirrespective identified messages on the operating system event queue. 5.The apparatus according to claim 1 wherein one or more messages on theoperating system event queue define user input to the window of the GUIfor the program.
 6. The apparatus according to claim 1 wherein one ormore predetermined sets of data are omitted from the log.
 7. Theapparatus according to claim 1 wherein the logged data comprises XML. 8.The apparatus according to claim 1 further operable to: identify a logfile for a selected application program; and display the recorded GUIactivity from the log file entries as a simulation of the selectedapplication program GUI.
 9. A method for recording graphical userinterface (GUI) data for a computer program, the method comprising thesteps of: monitoring an operating system event queue associated with aGUI for a program; identifying a first message on the operating systemevent queue defining a window of the GUI for the program; logging datarepresenting the window in a log associated with the program, whereinthe log is used to display a recorded GUI activity as a simulation ofthe program, and wherein the logging of the data is triggered inaccordance with a predetermined logging period associated with time,message data content, or message data quantity; identifying one or morefurther messages on the operating system event queue defining one ormore updates to the window; identifying a net change to the windowdefined in the further messages; and logging data representing theidentified net change to the window in the log.
 10. The method accordingto claim 9 wherein the data representing the window comprises aserialization of the window.
 11. The method according to claim 9 whereinthe data representing the net change to the window comprises aserialization of one or more changes to the window.
 12. The methodaccording to claim 9 wherein the data representing the window and thedata representing the net change to the window are derived from theirrespective identified messages on the operating system event queue. 13.The method according to claim 9 wherein one or more messages on theoperating system event queue define user input to the window of the GUIfor the program.
 14. The method according to claim 9 wherein one or morepredetermined sets of data are omitted from the log.
 15. The methodaccording claim 9 wherein the logged data comprises XML.
 16. The methodaccording to claim 9 further comprising the steps of: identifying a logfile for a selected application program; and displaying the recorded GUIactivity from the log file entries as a simulation of the selectedapplication program GUI.
 17. A computer program product for recordingGUI data for a computer program, the computer program product comprisinga computer-readable storage medium having computer-readable program codeembodied therewith, the computer-readable program code configured to:monitor an operating system event queue associated with a GUI for aprogram; identify a first message on the operating system event queuedefining a window of the GUI for the program; log data representing thewindow in a log associated with the program, wherein the log is used todisplay a recorded GUI activity as a simulation of the program, andwherein the logging of the data is triggered in accordance with apredetermined logging period associated with time, message data content,or message data quantity; identify one or more further messages on theoperating system event queue defining one or more updates to the window;identify a net change to the window defined in the further messages; andlog data representing the identified net change to the window in thelog.
 18. The computer program product according to claim 17 wherein thedata representing the window comprises a serialization of the window.19. The computer program product according to claim 17 wherein the datarepresenting the net change to the window comprises a serialization ofone or more changes to the window.
 20. The computer program productaccording to claim 17 wherein the data representing the window and thedata representing the net change to the window are derived from theirrespective identified messages on the operating system event queue. 21.The computer program product according to claim 17 wherein one or moremessages on the operating system event queue define user input to thewindow of the GUI for the program.